In
object-oriented programming
Object-oriented programming (OOP) is a programming paradigm based on the concept of " objects", which can contain data and code. The data is in the form of fields (often known as attributes or ''properties''), and the code is in the form of ...
, a member variable (sometimes called a member
field) is a
variable that is associated with a specific
object, and accessible for all its
methods (''member functions'').
In
class-based programming languages, these are distinguished into two types: ''
class variable
In class-based, object-oriented programming, a class variable is a variable defined in a class of which a single copy exists, regardless of how many instances of the class exist.
A class variable is not an instance variable. It is a special ...
s'' (also called ''static member variables''), where only one copy of the variable is shared with all
instance
Instantiation or instance may refer to:
Philosophy
* A modern concept similar to ''participation'' in classical Platonism; see the Theory of Forms
* The instantiation principle, the idea that in order for a property to exist, it must be had by ...
s of the
class; and ''
instance variables'', where each instance of the class has its own independent copy of the variable.
For Examples
C++
class Foo ;
int main ()
Java
public class Program
public class Foo
Python
class Foo:
def __init__(self):
self._bar = 0
@property
def bar(self):
return self._bar
@bar.setter
def bar(self, new_bar):
self._bar = new_bar
f = Foo()
f.bar = 100
print(f.bar)
Common Lisp
(defclass foo () (bar))
(defvar f (make-instance 'foo))
(setf (slot-value f 'bar) 100)
(print (slot-value f 'bar))
Ruby
/*
Ruby has three member variable types: class, class instance, and instance.
*/
class Dog
# The class variable is defined within the class body with two at-signs
# and describes data about all Dogs *and* their derived Dog breeds (if any)
@@sniffs = true
end
mutt = Dog.new
mutt.class.sniffs #=> true
class Poodle < Dog
# The "class instance variable" is defined within the class body with a single at-sign
# and describes data about only the Poodle class. It makes no claim about its parent class
# or any possible subclass derived from Poodle
@sheds = false
# When a new Poodle instance is created, by default it is untrained. The 'trained' variable
# is local to the initialize method and is used to set the instance variable @trained
# An instance variable is defined within an instance method and is a member of the Poodle instance
def initialize(trained = false)
@trained = trained
end
def has_manners?
@trained
end
end
p = Poodle.new
p.class.sheds #=> false
p.has_manners? #=> false
PHP
foo = 10;
// Prints 10.
echo $example->foo;
Lua
--region example
--- @class example_c
--- @field foo number Example "member variable".
local example_c =
local example_mt =
--- Creates an object from example.
--- @return example_c
function example_c.new(foo)
-- The first table argument is our object's member variables.
-- In a Lua object is a metatable and its member variables are table key-value pairs.
return setmetatable(, example_mt)
end
--endregion
-- Create an example object.
-- Set the "foo" member variable to 5.
local example = example_c.new(5)
-- Overwrite the "foo" member variable to 10.
example.foo = 10
-- Prints 10.
print(example.foo)
See also
*
Global variable
*
Local variable
*
Property (programming)
References
{{Reflist
Object-oriented programming
Variable (computer science)
Articles with example Python (programming language) code